import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// 声明本项目中用到的脉搏数据的数据结构和各种操作
public class PulseData {
    /*
        脉搏数据包括两种：病人端脉搏数据和医生端指法数据
     */

    // 声明病人端脉搏数据
    private HashMap patientSendData = new HashMap<String, Integer>();   // 病人端MCU发送到PC数据
    private HashMap patientReceiveData = new HashMap<String, Integer>();    // PC发送到病人端MCU数据

    // 声明医生端按压数据
    private HashMap doctorSendData = new HashMap<String, Integer>();    // 医生端MCU发送到PC数据
    private HashMap doctorReceiveData = new HashMap<String, Integer>(); // PC发送到医生端MCU数据

    /*
        创建一个构造函数
      */
    public PulseData() {
        // 初始化所有脉搏数据

        // 初始化病人端脉搏数据
        patientSendData.put('A', 0);    // 初始化病人端MCU发送到PC数据
        patientSendData.put('B', 0);    // 初始化病人端MCU发送到PC数据
        patientSendData.put('C', 0);    // 初始化病人端MCU发送到PC数据
        patientSendData.put('D', 0);    // 初始化病人端MCU发送到PC数据
        patientSendData.put('E', 0);    // 初始化病人端MCU发送到PC数据
        patientSendData.put('F', 0);    // 初始化病人端MCU发送到PC数据

        patientReceiveData.put('A', 0); // PC发送到病人端MCU数据
        patientReceiveData.put('B', 0); // PC发送到病人端MCU数据
        patientReceiveData.put('C', 0); // PC发送到病人端MCU数据

        // 初始化医生端按压数据
        doctorSendData.put('A', 0); // 初始化医生端MCU发送到PC数据
        doctorSendData.put('B', 0); // 初始化医生端MCU发送到PC数据
        doctorSendData.put('C', 0); // 初始化医生端MCU发送到PC数据

        doctorReceiveData.put('A', 0);  // 初始化PC发送到医生端MCU数据
        doctorReceiveData.put('B', 0);  // 初始化PC发送到医生端MCU数据
        doctorReceiveData.put('C', 0);  // 初始化PC发送到医生端MCU数据
    }

    /*
        创建最基本的变量读写方法
        需要使用重载创建两种写变量方法：一种是形参为Map类型的，一种是利用多个形参传入变量的
        需要使用重载创建两种读变量方法：一种是直接按照Map类型的数据读取变量的，一种是利用字符串类型读取变量的
     */

    // 形参为Map类型的写变量方法
    public void setPatientSendData(HashMap patientSendData) {
        this.patientSendData = patientSendData;
    }

    public void setPatientReceiveData(HashMap patientReceiveData) {
        this.patientReceiveData = patientReceiveData;
    }

    public void setDoctorSendData(HashMap doctorSendData) {
        this.doctorSendData = doctorSendData;
    }

    public void setDoctorReceiveData(HashMap doctorReceiveData) {
        this.doctorReceiveData = doctorReceiveData;
    }

    // 利用多个形参写入变量的方法
    public void setPatientSendData(int valueA, int valueB, int valueC, int valueD, int valueE, int valueF) {
        patientSendData.put('A', valueA);
        patientSendData.put('B', valueB);
        patientSendData.put('C', valueC);
        patientSendData.put('D', valueD);
        patientSendData.put('E', valueE);
        patientSendData.put('F', valueF);
    }

    public void setPatientReceiveData(int valueA, int valueB, int valueC) {
        patientReceiveData.put('A', valueA);
        patientReceiveData.put('B', valueB);
        patientReceiveData.put('C', valueC);
    }

    public void setDoctorSendData(int valueA, int valueB, int valueC) {
        doctorSendData.put('A', valueA);
        doctorSendData.put('B', valueB);
        doctorSendData.put('C', valueC);
    }

    public void setDoctorReceiveData(int valueA, int valueB, int valueC) {
        doctorReceiveData.put('A', valueA);
        doctorReceiveData.put('B', valueB);
        doctorReceiveData.put('C', valueC);
    }

    // 直接按照Map类型数据的读变量方法
    public HashMap<String, Integer> getPatientSendData() {
        return patientSendData;
    }

    public HashMap<String, Integer> getPatientReceiveData() {
        return patientReceiveData;
    }

    public HashMap<String, Integer> getDoctorSendData() {
        return doctorSendData;
    }

    public HashMap<String, Integer> getDoctorReceiveData() {
        return doctorReceiveData;
    }

    // 利用字符串类型的读变量方法
    public String printPatientSendData() {
        String result = "{\"A\":" + patientSendData.get('A') + ",\"B\":" + patientSendData.get('B') + ",\"C\":" + patientSendData.get('C') + ",\"D\":" + patientSendData.get('D') + ",\"E\":" + patientSendData.get('E') + ",\"F\":" + patientSendData.get('F') + "}";

        return result;
    }

    public String printPatientReceiveData() {
        String result = "{\"A\":" + patientReceiveData.get('A') + ",\"B\":" + patientReceiveData.get('B') + ",\"C\":" + patientReceiveData.get('C') + "}";

        return result;
    }

    public String printDoctorSendData() {
        String result = "{\"A\":" + doctorSendData.get('A') + ",\"B\":" + doctorSendData.get('B') + ",\"C\":" + doctorSendData.get('C') + "}";

        return result;
    }

    public String printDoctorReceiveData() {
        String result = "{\"A\":" + doctorReceiveData.get('A') + ",\"B\":" + doctorReceiveData.get('B') + ",\"C\":" + doctorReceiveData.get('C') + "}";

        return result;
    }

    /*
        创建从文件中读写数据的方法
        从文件中读数据包括读取医生端数据、读取病人端数据
        向文件中写入数据包括写入医生端数据、写入病人端数据
     */

    // 从文件中读取病人端发送到PC的数据
    public List<HashMap<String, Integer>> readPatientSendData(String fileName) {
        // 创建一个存储数据的列表
        List<HashMap<String, Integer>> list = new ArrayList<HashMap<String, Integer>>();

        try {
            BufferedReader reader = new BufferedReader(new FileReader(fileName));   // 创建一个读文件流
            String line = null; // 创建一个字符串，保存按行读取的文件内容

            // 按行读取文件内容
            while((line = reader.readLine()) != null) {
                String item[] = line.split(",");    // 文件为csv逗号分隔符文件，按照逗号对文件每一行内容进行切分

                HashMap<String, Integer> data = new HashMap<String, Integer>(); // 声明一个Map集合，将读取到的每一行数据存入其中

                // 按照病人端发送到PC的数据协议进行存储
                data.put("A", Integer.parseInt(item[0]));
                data.put("B", Integer.parseInt(item[1]));
                data.put("C", Integer.parseInt(item[2]));
                data.put("D", Integer.parseInt(item[3]));
                data.put("E", Integer.parseInt(item[4]));
                data.put("F", Integer.parseInt(item[5]));

                list.add(data);
            }
        } catch(Exception e) {
            e.printStackTrace();
        }

        return list;
    }

    // 从文件中读取PC发送到病人端的数据
    public List<HashMap<String, Integer>> readPatientReceiveData(String fileName) {
        // 创建一个存储数据的列表
        List<HashMap<String, Integer>> list = new ArrayList<HashMap<String, Integer>>();

        try {
            BufferedReader reader = new BufferedReader(new FileReader(fileName));   // 创建一个读文件流
            String line = null; // 创建一个字符串，保存按行读取的文件内容

            // 按行读取文件内容
            while((line = reader.readLine()) != null) {
                String item[] = line.split(",");    // 文件为csv逗号分隔符文件，按照逗号对文件每一行内容进行切分

                HashMap<String, Integer> data = new HashMap<String, Integer>(); // 声明一个Map集合，将读取到的每一行数据存入其中

                // 按照病人端发送到PC的数据协议进行存储
                data.put("A", Integer.parseInt(item[0]));
                data.put("B", Integer.parseInt(item[1]));
                data.put("C", Integer.parseInt(item[2]));

                list.add(data);
            }
        } catch(Exception e) {
            e.printStackTrace();
        }

        return list;
    }

    // 从文件中读取医生端发送到PC的数据
    public List<HashMap<String, Integer>> readDoctorSendData(String fileName) {
        // 创建一个存储数据的列表
        List<HashMap<String, Integer>> list = new ArrayList<HashMap<String, Integer>>();

        try {
            BufferedReader reader = new BufferedReader(new FileReader(fileName));   // 创建一个读文件流
            String line = null; // 创建一个字符串，保存按行读取的文件内容

            // 按行读取文件内容
            while((line = reader.readLine()) != null) {
                String item[] = line.split(",");    // 文件为csv逗号分隔符文件，按照逗号对文件每一行内容进行切分

                HashMap<String, Integer> data = new HashMap<String, Integer>(); // 声明一个Map集合，将读取到的每一行数据存入其中

                // 按照病人端发送到PC的数据协议进行存储
                data.put("A", Integer.parseInt(item[0]));
                data.put("B", Integer.parseInt(item[1]));
                data.put("C", Integer.parseInt(item[2]));

                list.add(data);
            }
        } catch(Exception e) {
            e.printStackTrace();
        }

        return list;
    }

    // 从文件中读取PC发送到医生端的数据
    public List<HashMap<String, Integer>> readDoctorReceiveData(String fileName) {
        // 创建一个存储数据的列表
        List<HashMap<String, Integer>> list = new ArrayList<HashMap<String, Integer>>();

        try {
            BufferedReader reader = new BufferedReader(new FileReader(fileName));   // 创建一个读文件流
            String line = null; // 创建一个字符串，保存按行读取的文件内容

            // 按行读取文件内容
            while((line = reader.readLine()) != null) {
                String item[] = line.split(",");    // 文件为csv逗号分隔符文件，按照逗号对文件每一行内容进行切分

                HashMap<String, Integer> data = new HashMap<String, Integer>(); // 声明一个Map集合，将读取到的每一行数据存入其中

                // 按照病人端发送到PC的数据协议进行存储
                data.put("A", Integer.parseInt(item[0]));
                data.put("B", Integer.parseInt(item[1]));
                data.put("C", Integer.parseInt(item[2]));

                list.add(data);
            }
        } catch(Exception e) {
            e.printStackTrace();
        }

        return list;
    }

    // 向文件写入病人端发送到PC的数据
    public void writePatientSendData(String fileName, HashMap<String, Integer> patientSendData) {
        try {
            FileWriter writer = new FileWriter(fileName, true);

            // 将数据读取为逗号分隔符的形式
            String content = patientSendData.get('A') + "," + patientSendData.get('B') + "," + patientSendData.get('C') + "," + patientSendData.get('D') + "," + patientSendData.get('E') + "," + patientSendData.get('F') + "\n";

            writer.write(content); // 将字符串写入文件

            writer.flush();
            writer.close();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }

    // 向文件中写入PC发送到病人端的数据
    public void writePatientReceiveData(String fileName, HashMap<String, Integer> patientReceiveData) {
        try {
            FileWriter writer = new FileWriter(fileName, true);

            // 将数据读取为逗号分隔符的形式
            String content = patientReceiveData.get('A') + "," + patientReceiveData.get('B') + "," + patientReceiveData.get('C') + "\n";

            writer.write(content); // 将字符串写入文件

            writer.flush();
            writer.close();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }

    // 向文件中写入医生端发送到PC的数据
    public void writeDoctorSendData(String fileName, HashMap<String, Integer> doctorSendData) {
        try {
            FileWriter writer = new FileWriter(fileName, true);

            // 将数据读取为逗号分隔符的形式
            String content = doctorSendData.get('A') + "," + doctorSendData.get('B') + "," + doctorSendData.get('C') + "\n";
            writer.write(content); // 将字符串写入文件

            writer.flush();
            writer.close();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }

    // 向文件中写入PC发送到医生端的数据
    public void writeDoctorReceiveData(String fileName, HashMap<String, Integer> doctorReceiveData) {
        try {
            FileWriter writer = new FileWriter(fileName, true);

            // 将数据读取为逗号分隔符的形式
            String content = doctorReceiveData.get('A') + "," + doctorReceiveData.get('B') + "," + doctorReceiveData.get('C') + "\n";
            writer.write(content); // 将字符串写入文件

            writer.flush();
            writer.close();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}
